{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "65f88975",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import math\n",
    "from math import log"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e9b5f1dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_data():\n",
    "    datasets = [['青年', '否', '否', '一般', '否'],\n",
    "               ['青年', '否', '否', '好', '否'],\n",
    "               ['青年', '是', '否', '好', '是'],\n",
    "               ['青年', '是', '是', '一般', '是'],\n",
    "               ['青年', '否', '否', '一般', '否'],\n",
    "               ['中年', '否', '否', '一般', '否'],\n",
    "               ['中年', '否', '否', '好', '否'],\n",
    "               ['中年', '是', '是', '好', '是'],\n",
    "               ['中年', '否', '是', '非常好', '是'],\n",
    "               ['中年', '否', '是', '非常好', '是'],\n",
    "               ['老年', '否', '是', '非常好', '是'],\n",
    "               ['老年', '否', '是', '好', '是'],\n",
    "               ['老年', '是', '否', '好', '是'],\n",
    "               ['老年', '是', '否', '非常好', '是'],\n",
    "               ['老年', '否', '否', '一般', '否'],\n",
    "               ]\n",
    "    labels = [u'年龄', u'有工作', u'有自己的房子', u'信贷情况', u'类别']\n",
    "    # 返回数据集和每个维度的名称\n",
    "    return datasets, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9ccbe1b7",
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets, labels = create_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4596f36e",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data = pd.DataFrame(datasets, columns=labels) #请将本行代码补充完整"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cb462ea4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>年龄</th>\n",
       "      <th>有工作</th>\n",
       "      <th>有自己的房子</th>\n",
       "      <th>信贷情况</th>\n",
       "      <th>类别</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>青年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>青年</td>\n",
       "      <td>是</td>\n",
       "      <td>是</td>\n",
       "      <td>一般</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>中年</td>\n",
       "      <td>是</td>\n",
       "      <td>是</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>老年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>老年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    年龄 有工作 有自己的房子 信贷情况 类别\n",
       "0   青年   否      否   一般  否\n",
       "1   青年   否      否    好  否\n",
       "2   青年   是      否    好  是\n",
       "3   青年   是      是   一般  是\n",
       "4   青年   否      否   一般  否\n",
       "5   中年   否      否   一般  否\n",
       "6   中年   否      否    好  否\n",
       "7   中年   是      是    好  是\n",
       "8   中年   否      是  非常好  是\n",
       "9   中年   否      是  非常好  是\n",
       "10  老年   否      是  非常好  是\n",
       "11  老年   否      是    好  是\n",
       "12  老年   是      否    好  是\n",
       "13  老年   是      否  非常好  是\n",
       "14  老年   否      否   一般  否"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7fea9a8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算给定数据集的熵（信息熵）\n",
    "def calc_ent(datasets):\n",
    "    # 计算数据集的长度\n",
    "    data_length = len(datasets)\n",
    "    # 统计数据集中每个类别的出现次数\n",
    "    label_count = {}\n",
    "    for i in range(data_length):\n",
    "        # 获取每个样本的标签\n",
    "        label = datasets[i][-1]\n",
    "        # 如果该类别不在label_count中，则添加到label_count中\n",
    "        if label not in label_count:\n",
    "            label_count[label] = 0\n",
    "        # 统计该类别的出现次数\n",
    "        label_count[label] += 1\n",
    "    # 计算熵\n",
    "    ent = -sum([(p / data_length) * log(p / data_length, 2)\n",
    "                for p in label_count.values()])\n",
    "    return ent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "64762b81",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算给定数据集在指定特征上的条件熵\n",
    "def cond_ent(datasets, axis=0):\n",
    "    # 计算数据集的长度\n",
    "    data_length = len(datasets)\n",
    "    # 使用字典feature_sets存储在指定特征上的不同取值对应的样本集合\n",
    "    feature_sets = {}\n",
    "    for i in range(data_length):\n",
    "        # 获取每个样本在指定特征上的取值\n",
    "        feature = datasets[i][axis]\n",
    "        # 如果该取值不在feature_sets中，则添加到feature_sets中\n",
    "        if feature not in feature_sets:\n",
    "            feature_sets[feature] = []\n",
    "        # 将该样本添加到对应取值的样本集合中\n",
    "        feature_sets[feature].append(datasets[i])\n",
    "    # 计算条件熵\n",
    "    cond_ent = sum([(len(p) / data_length) * calc_ent(p)\n",
    "                    for p in feature_sets.values()])\n",
    "    return cond_ent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a285a19b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9709505944546686"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calc_ent(datasets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "718c7bc8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算信息增益\n",
    "def info_gain(ent, cond_ent):\n",
    "    # 信息增益等于熵减去条件熵\n",
    "    return ent - cond_ent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2a0de1df",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用信息增益选择最佳特征作为根节点特征进行决策树的训练\n",
    "def info_gain_train(datasets):\n",
    "    # 计算特征的数量\n",
    "    count = len(datasets[0]) - 1\n",
    "    # 计算整个数据集的熵\n",
    "    ent = calc_ent(datasets)\n",
    "    # 存储每个特征的信息增益\n",
    "    best_feature = []\n",
    "    for c in range(count):\n",
    "        # 计算每个特征的条件熵\n",
    "        c_info_gain = info_gain(ent, cond_ent(datasets, axis=c))\n",
    "        # 将特征及其对应的信息增益存入best_feature列表中\n",
    "        best_feature.append((c, c_info_gain))\n",
    "        # 输出每个特征的信息增益\n",
    "        print('特征({}) 的信息增益为： {:.3f}'.format(labels[c], c_info_gain))\n",
    "    # 找到信息增益最大的特征\n",
    "    best_ = max(best_feature, key=lambda x: x[-1])\n",
    "    # 返回信息增益最大的特征作为根节点特征\n",
    "    return '特征({})的信息增益最大，选择为根节点特征'.format(labels[best_[0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "bdc143ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "特征(年龄) 的信息增益为： 0.083\n",
      "特征(有工作) 的信息增益为： 0.324\n",
      "特征(有自己的房子) 的信息增益为： 0.420\n",
      "特征(信贷情况) 的信息增益为： 0.363\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'特征(有自己的房子)的信息增益最大，选择为根节点特征'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "info_gain_train(np.array(datasets))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e5d4ecd9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义节点类 二叉树\n",
    "class Node:\n",
    "    def __init__(self, root=True, label=None, feature_name=None, feature=None):\n",
    "        self.root = root\n",
    "        self.label = label\n",
    "        self.feature_name = feature_name\n",
    "        self.feature = feature\n",
    "        self.tree = {}\n",
    "        self.result = {\n",
    "            'label:': self.label,\n",
    "            'feature': self.feature,\n",
    "            'tree': self.tree\n",
    "        }\n",
    "\n",
    "    def __repr__(self):\n",
    "        return '{}'.format(self.result)\n",
    "\n",
    "    def add_node(self, val, node):\n",
    "        self.tree[val] = node\n",
    "\n",
    "    def predict(self, features):\n",
    "        if self.root is True:\n",
    "            return self.label\n",
    "        return self.tree[features[self.feature]].predict(features)\n",
    "\n",
    "\n",
    "class DTree:\n",
    "    def __init__(self, epsilon=0.1):\n",
    "        self.epsilon = epsilon\n",
    "        self._tree = {}\n",
    "\n",
    "    # 熵\n",
    "    @staticmethod\n",
    "    def calc_ent(datasets):\n",
    "        data_length = len(datasets)\n",
    "        label_count = {}\n",
    "        for i in range(data_length):\n",
    "            label = datasets[i][-1]\n",
    "            if label not in label_count:\n",
    "                label_count[label] = 0\n",
    "            label_count[label] += 1\n",
    "        ent = -sum([(p / data_length) * log(p / data_length, 2)\n",
    "                    for p in label_count.values()])\n",
    "        return ent\n",
    "\n",
    "    # 经验条件熵\n",
    "    def cond_ent(self, datasets, axis=0):\n",
    "        data_length = len(datasets)\n",
    "        feature_sets = {}\n",
    "        for i in range(data_length):\n",
    "            feature = datasets[i][axis]\n",
    "            if feature not in feature_sets:\n",
    "                feature_sets[feature] = []\n",
    "            feature_sets[feature].append(datasets[i])\n",
    "        cond_ent = sum([(len(p) / data_length) * self.calc_ent(p)\n",
    "                        for p in feature_sets.values()])\n",
    "        return cond_ent\n",
    "\n",
    "    # 信息增益\n",
    "    @staticmethod\n",
    "    def info_gain(ent, cond_ent):\n",
    "        return ent - cond_ent\n",
    "\n",
    "    def info_gain_train(self, datasets):\n",
    "        count = len(datasets[0]) - 1\n",
    "        ent = self.calc_ent(datasets)\n",
    "        best_feature = []\n",
    "        for c in range(count):\n",
    "            c_info_gain = self.info_gain(ent, self.cond_ent(datasets, axis=c))\n",
    "            best_feature.append((c, c_info_gain))\n",
    "        # 比较大小\n",
    "        best_ = max(best_feature, key=lambda x: x[-1])\n",
    "        return best_\n",
    "\n",
    "    def train(self, train_data):\n",
    "        \"\"\"\n",
    "        input:数据集D(DataFrame格式)，特征集A，阈值eta\n",
    "        output:决策树T\n",
    "        \"\"\"\n",
    "        _, y_train, features = train_data.iloc[:, :\n",
    "                                               -1], train_data.iloc[:,\n",
    "                                                                    -1], train_data.columns[:\n",
    "                                                                                            -1]\n",
    "        # 1,若D中实例属于同一类Ck，则T为单节点树，并将类Ck作为结点的类标记，返回T\n",
    "        if len(y_train.value_counts()) == 1:\n",
    "            return Node(root=True, label=y_train.iloc[0])\n",
    "\n",
    "        # 2, 若A为空，则T为单节点树，将D中实例树最大的类Ck作为该节点的类标记，返回T\n",
    "        if len(features) == 0:\n",
    "            return Node(\n",
    "                root=True,\n",
    "                label=y_train.value_counts().sort_values(\n",
    "                    ascending=False).index[0])\n",
    "\n",
    "        # 3,计算最大信息增益 同5.1,Ag为信息增益最大的特征\n",
    "        max_feature, max_info_gain = self.info_gain_train(np.array(train_data))\n",
    "        max_feature_name = features[max_feature]\n",
    "\n",
    "        # 4,Ag的信息增益小于阈值eta,则置T为单节点树，并将D中是实例数最大的类Ck作为该节点的类标记，返回T\n",
    "        if max_info_gain < self.epsilon:\n",
    "            return Node(\n",
    "                root=True,\n",
    "                label=y_train.value_counts().sort_values(\n",
    "                    ascending=False).index[0])\n",
    "\n",
    "        # 5,构建Ag子集\n",
    "        node_tree = Node(\n",
    "            root=False, feature_name=max_feature_name, feature=max_feature)\n",
    "\n",
    "        feature_list = train_data[max_feature_name].value_counts().index\n",
    "        for f in feature_list:\n",
    "            sub_train_df = train_data.loc[train_data[max_feature_name] ==\n",
    "                                          f].drop([max_feature_name], axis=1)\n",
    "\n",
    "            # 6, 递归生成树\n",
    "            sub_tree = self.train(sub_train_df)\n",
    "            node_tree.add_node(f, sub_tree)\n",
    "\n",
    "        # pprint.pprint(node_tree.tree)\n",
    "        return node_tree\n",
    "\n",
    "    def fit(self, train_data):\n",
    "        self._tree = self.train(train_data)\n",
    "        return self._tree\n",
    "\n",
    "    def predict(self, X_test):\n",
    "        return self._tree.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e74a9ac1",
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets, labels = create_data()\n",
    "data_df = pd.DataFrame(datasets, columns=labels)\n",
    "dt = DTree()\n",
    "tree = dt.fit(data_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c2f2412f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'label:': None, 'feature': 2, 'tree': {'否': {'label:': None, 'feature': 1, 'tree': {'否': {'label:': '否', 'feature': None, 'tree': {}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "1a23b358",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'否'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt.predict(['老年', '否', '否', '一般'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "479c4eb5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "from sklearn.model_selection import train_test_split\n",
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1df1771c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# data\n",
    "def create_data():\n",
    "    iris = load_iris() #请将本行代码补充完整       \n",
    "    df = pd.DataFrame(iris.data, columns=iris.feature_names)\n",
    "    df['label'] = iris.target\n",
    "    df.columns = [\n",
    "        'sepal length', 'sepal width', 'petal length', 'petal width', 'label'\n",
    "    ]\n",
    "    data = np.array(df.iloc[:100, [0, 1, -1]])\n",
    "    # print(data)\n",
    "    return data[:, :2], data[:, -1],iris.feature_names[0:2]\n",
    "\n",
    "\n",
    "X, y,feature_name= create_data()\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "9dc39a2a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.tree import export_graphviz\n",
    "import graphviz\n",
    "from sklearn import tree\n",
    "\n",
    "clf = DecisionTreeClassifier()\n",
    "clf.fit(X_train, y_train,)\n",
    "\n",
    "clf.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "0a2c59c4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0.5909090909090909, 0.9, 'x[0] <= 5.45\\ngini = 0.498\\nsamples = 70\\nvalue = [33, 37]'),\n",
       " Text(0.36363636363636365, 0.7, 'x[1] <= 2.8\\ngini = 0.208\\nsamples = 34\\nvalue = [30, 4]'),\n",
       " Text(0.18181818181818182, 0.5, 'x[0] <= 4.75\\ngini = 0.375\\nsamples = 4\\nvalue = [1, 3]'),\n",
       " Text(0.09090909090909091, 0.3, 'gini = 0.0\\nsamples = 1\\nvalue = [1, 0]'),\n",
       " Text(0.2727272727272727, 0.3, 'gini = 0.0\\nsamples = 3\\nvalue = [0, 3]'),\n",
       " Text(0.5454545454545454, 0.5, 'x[0] <= 5.35\\ngini = 0.064\\nsamples = 30\\nvalue = [29, 1]'),\n",
       " Text(0.45454545454545453, 0.3, 'gini = 0.0\\nsamples = 27\\nvalue = [27, 0]'),\n",
       " Text(0.6363636363636364, 0.3, 'x[1] <= 3.35\\ngini = 0.444\\nsamples = 3\\nvalue = [2, 1]'),\n",
       " Text(0.5454545454545454, 0.1, 'gini = 0.0\\nsamples = 1\\nvalue = [0, 1]'),\n",
       " Text(0.7272727272727273, 0.1, 'gini = 0.0\\nsamples = 2\\nvalue = [2, 0]'),\n",
       " Text(0.8181818181818182, 0.7, 'x[1] <= 3.45\\ngini = 0.153\\nsamples = 36\\nvalue = [3, 33]'),\n",
       " Text(0.7272727272727273, 0.5, 'gini = 0.0\\nsamples = 33\\nvalue = [0, 33]'),\n",
       " Text(0.9090909090909091, 0.5, 'gini = 0.0\\nsamples = 3\\nvalue = [3, 0]')]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tree.plot_tree(clf) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "934a9160",
   "metadata": {},
   "outputs": [],
   "source": [
    "tree_pic = export_graphviz(clf, out_file=\"mytree.pdf\")\n",
    "with open('mytree.pdf') as f:\n",
    "    dot_graph = f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "a188a1cf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 12.2.1 (20241206.2353)\n",
       " -->\n",
       "<!-- Title: Tree Pages: 1 -->\n",
       "<svg width=\"566pt\" height=\"477pt\"\n",
       " viewBox=\"0.00 0.00 566.00 477.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 473)\">\n",
       "<title>Tree</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-473 562,-473 562,4 -4,4\"/>\n",
       "<!-- 0 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>0</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"389.5,-469 280.5,-469 280.5,-401 389.5,-401 389.5,-469\"/>\n",
       "<text text-anchor=\"middle\" x=\"335\" y=\"-451.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[0] &lt;= 5.45</text>\n",
       "<text text-anchor=\"middle\" x=\"335\" y=\"-436.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.498</text>\n",
       "<text text-anchor=\"middle\" x=\"335\" y=\"-421.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 70</text>\n",
       "<text text-anchor=\"middle\" x=\"335\" y=\"-406.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [33, 37]</text>\n",
       "</g>\n",
       "<!-- 1 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>1</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"325.75,-365 224.25,-365 224.25,-297 325.75,-297 325.75,-365\"/>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-347.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[1] &lt;= 2.8</text>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-332.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.208</text>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-317.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 34</text>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-302.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [30, 4]</text>\n",
       "</g>\n",
       "<!-- 0&#45;&gt;1 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>0&#45;&gt;1</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M315.35,-400.6C310.59,-392.5 305.43,-383.72 300.44,-375.24\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"303.54,-373.62 295.46,-366.78 297.51,-377.17 303.54,-373.62\"/>\n",
       "<text text-anchor=\"middle\" x=\"288.42\" y=\"-383.87\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">True</text>\n",
       "</g>\n",
       "<!-- 10 -->\n",
       "<g id=\"node11\" class=\"node\">\n",
       "<title>10</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"445.75,-365 344.25,-365 344.25,-297 445.75,-297 445.75,-365\"/>\n",
       "<text text-anchor=\"middle\" x=\"395\" y=\"-347.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[1] &lt;= 3.45</text>\n",
       "<text text-anchor=\"middle\" x=\"395\" y=\"-332.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.153</text>\n",
       "<text text-anchor=\"middle\" x=\"395\" y=\"-317.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 36</text>\n",
       "<text text-anchor=\"middle\" x=\"395\" y=\"-302.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [3, 33]</text>\n",
       "</g>\n",
       "<!-- 0&#45;&gt;10 -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>0&#45;&gt;10</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M354.65,-400.6C359.41,-392.5 364.57,-383.72 369.56,-375.24\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"372.49,-377.17 374.54,-366.78 366.46,-373.62 372.49,-377.17\"/>\n",
       "<text text-anchor=\"middle\" x=\"381.58\" y=\"-383.87\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">False</text>\n",
       "</g>\n",
       "<!-- 2 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>2</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"206,-261 112,-261 112,-193 206,-193 206,-261\"/>\n",
       "<text text-anchor=\"middle\" x=\"159\" y=\"-243.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[0] &lt;= 4.75</text>\n",
       "<text text-anchor=\"middle\" x=\"159\" y=\"-228.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.375</text>\n",
       "<text text-anchor=\"middle\" x=\"159\" y=\"-213.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 4</text>\n",
       "<text text-anchor=\"middle\" x=\"159\" y=\"-198.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [1, 3]</text>\n",
       "</g>\n",
       "<!-- 1&#45;&gt;2 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>1&#45;&gt;2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M237.02,-296.6C227,-287.8 216.08,-278.19 205.67,-269.03\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"208.03,-266.45 198.2,-262.47 203.4,-271.7 208.03,-266.45\"/>\n",
       "</g>\n",
       "<!-- 5 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>5</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"325.75,-261 224.25,-261 224.25,-193 325.75,-193 325.75,-261\"/>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-243.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[0] &lt;= 5.35</text>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-228.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.064</text>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-213.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 30</text>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-198.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [29, 1]</text>\n",
       "</g>\n",
       "<!-- 1&#45;&gt;5 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>1&#45;&gt;5</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M275,-296.6C275,-289.03 275,-280.87 275,-272.9\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"278.5,-272.99 275,-262.99 271.5,-272.99 278.5,-272.99\"/>\n",
       "</g>\n",
       "<!-- 3 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>3</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"94,-149.5 0,-149.5 0,-96.5 94,-96.5 94,-149.5\"/>\n",
       "<text text-anchor=\"middle\" x=\"47\" y=\"-132.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"47\" y=\"-117.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 1</text>\n",
       "<text text-anchor=\"middle\" x=\"47\" y=\"-102.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [1, 0]</text>\n",
       "</g>\n",
       "<!-- 2&#45;&gt;3 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>2&#45;&gt;3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M122.33,-192.6C109.89,-181.27 96,-168.62 83.56,-157.3\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"86.1,-154.87 76.35,-150.73 81.38,-160.05 86.1,-154.87\"/>\n",
       "</g>\n",
       "<!-- 4 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>4</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"206,-149.5 112,-149.5 112,-96.5 206,-96.5 206,-149.5\"/>\n",
       "<text text-anchor=\"middle\" x=\"159\" y=\"-132.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"159\" y=\"-117.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 3</text>\n",
       "<text text-anchor=\"middle\" x=\"159\" y=\"-102.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [0, 3]</text>\n",
       "</g>\n",
       "<!-- 2&#45;&gt;4 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>2&#45;&gt;4</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M159,-192.6C159,-182.47 159,-171.28 159,-160.93\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"162.5,-161.22 159,-151.22 155.5,-161.22 162.5,-161.22\"/>\n",
       "</g>\n",
       "<!-- 6 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>6</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"325.75,-149.5 224.25,-149.5 224.25,-96.5 325.75,-96.5 325.75,-149.5\"/>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-132.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-117.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 27</text>\n",
       "<text text-anchor=\"middle\" x=\"275\" y=\"-102.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [27, 0]</text>\n",
       "</g>\n",
       "<!-- 5&#45;&gt;6 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>5&#45;&gt;6</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M275,-192.6C275,-182.47 275,-171.28 275,-160.93\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"278.5,-161.22 275,-151.22 271.5,-161.22 278.5,-161.22\"/>\n",
       "</g>\n",
       "<!-- 7 -->\n",
       "<g id=\"node8\" class=\"node\">\n",
       "<title>7</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"438,-157 344,-157 344,-89 438,-89 438,-157\"/>\n",
       "<text text-anchor=\"middle\" x=\"391\" y=\"-139.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[1] &lt;= 3.35</text>\n",
       "<text text-anchor=\"middle\" x=\"391\" y=\"-124.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.444</text>\n",
       "<text text-anchor=\"middle\" x=\"391\" y=\"-109.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 3</text>\n",
       "<text text-anchor=\"middle\" x=\"391\" y=\"-94.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [2, 1]</text>\n",
       "</g>\n",
       "<!-- 5&#45;&gt;7 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>5&#45;&gt;7</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M312.98,-192.6C323,-183.8 333.92,-174.19 344.33,-165.03\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"346.6,-167.7 351.8,-158.47 341.97,-162.45 346.6,-167.7\"/>\n",
       "</g>\n",
       "<!-- 8 -->\n",
       "<g id=\"node9\" class=\"node\">\n",
       "<title>8</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"382,-53 288,-53 288,0 382,0 382,-53\"/>\n",
       "<text text-anchor=\"middle\" x=\"335\" y=\"-35.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"335\" y=\"-20.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 1</text>\n",
       "<text text-anchor=\"middle\" x=\"335\" y=\"-5.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [0, 1]</text>\n",
       "</g>\n",
       "<!-- 7&#45;&gt;8 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>7&#45;&gt;8</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M371.26,-88.68C366.38,-80.45 361.13,-71.59 356.18,-63.25\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"359.23,-61.51 351.12,-54.7 353.2,-65.08 359.23,-61.51\"/>\n",
       "</g>\n",
       "<!-- 9 -->\n",
       "<g id=\"node10\" class=\"node\">\n",
       "<title>9</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"494,-53 400,-53 400,0 494,0 494,-53\"/>\n",
       "<text text-anchor=\"middle\" x=\"447\" y=\"-35.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"447\" y=\"-20.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 2</text>\n",
       "<text text-anchor=\"middle\" x=\"447\" y=\"-5.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [2, 0]</text>\n",
       "</g>\n",
       "<!-- 7&#45;&gt;9 -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>7&#45;&gt;9</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M410.74,-88.68C415.62,-80.45 420.87,-71.59 425.82,-63.25\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"428.8,-65.08 430.88,-54.7 422.77,-61.51 428.8,-65.08\"/>\n",
       "</g>\n",
       "<!-- 11 -->\n",
       "<g id=\"node12\" class=\"node\">\n",
       "<title>11</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"445.75,-253.5 344.25,-253.5 344.25,-200.5 445.75,-200.5 445.75,-253.5\"/>\n",
       "<text text-anchor=\"middle\" x=\"395\" y=\"-236.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"395\" y=\"-221.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 33</text>\n",
       "<text text-anchor=\"middle\" x=\"395\" y=\"-206.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [0, 33]</text>\n",
       "</g>\n",
       "<!-- 10&#45;&gt;11 -->\n",
       "<g id=\"edge11\" class=\"edge\">\n",
       "<title>10&#45;&gt;11</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M395,-296.6C395,-286.47 395,-275.28 395,-264.93\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"398.5,-265.22 395,-255.22 391.5,-265.22 398.5,-265.22\"/>\n",
       "</g>\n",
       "<!-- 12 -->\n",
       "<g id=\"node13\" class=\"node\">\n",
       "<title>12</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"558,-253.5 464,-253.5 464,-200.5 558,-200.5 558,-253.5\"/>\n",
       "<text text-anchor=\"middle\" x=\"511\" y=\"-236.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"511\" y=\"-221.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 3</text>\n",
       "<text text-anchor=\"middle\" x=\"511\" y=\"-206.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [3, 0]</text>\n",
       "</g>\n",
       "<!-- 10&#45;&gt;12 -->\n",
       "<g id=\"edge12\" class=\"edge\">\n",
       "<title>10&#45;&gt;12</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M432.98,-296.6C445.87,-285.27 460.25,-272.62 473.13,-261.3\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"475.43,-263.94 480.63,-254.71 470.81,-258.68 475.43,-263.94\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.sources.Source at 0x13e874510>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "graphviz.Source(dot_graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "015990b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "25c11f67",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a random dataset\n",
    "rng = np.random.RandomState(1)\n",
    "X = np.sort(5 * rng.rand(80, 1), axis=0)\n",
    "y = np.sin(X).ravel()\n",
    "y[::5] += 3 * (0.5 - rng.rand(16))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "15ce50ac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Fit regression model\n",
    "regr_1 = DecisionTreeRegressor(max_depth=2)\n",
    "regr_2 = DecisionTreeRegressor(max_depth=5)\n",
    "regr_1.fit(X, y)\n",
    "regr_2.fit(X, y)\n",
    "\n",
    "# Predict\n",
    "X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]\n",
    "y_1 = regr_1.predict(X_test)\n",
    "y_2 = regr_2.predict(X_test)\n",
    "\n",
    "# Plot the results\n",
    "plt.figure()\n",
    "plt.scatter(X, y, s=20, edgecolor=\"black\", c=\"darkorange\", label=\"data\")\n",
    "plt.plot(X_test, y_1, color=\"cornflowerblue\", label=\"max_depth=2\", linewidth=2)\n",
    "plt.plot(X_test, y_2, color=\"yellowgreen\", label=\"max_depth=5\", linewidth=2)\n",
    "plt.xlabel(\"data\")\n",
    "plt.ylabel(\"target\")\n",
    "plt.title(\"Decision Tree Regression\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "2240453f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入库\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn import datasets\n",
    "from sklearn.model_selection import train_test_split\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn import metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "4cff6099",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(150, 4) (150,)\n"
     ]
    }
   ],
   "source": [
    "# 导入数据集\n",
    "X = datasets.load_iris()  # 以全部字典形式返回,有data,target,target_names三个键\n",
    "data = X.data\n",
    "target = X.target\n",
    "name = X.target_names\n",
    "x, y = datasets.load_iris(return_X_y=True)  # 能一次性取前2个\n",
    "print(x.shape, y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "45a0810f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 数据分为训练集和测试集\n",
    "x_train, x_test, y_train, y_test = train_test_split(x,\n",
    "                                                    y,\n",
    "                                                    test_size=0.2,\n",
    "                                                    random_state=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "8eb0924e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最优分类器: {'criterion': 'gini', 'max_depth': 30, 'min_impurity_decrease': 0.1, 'min_samples_leaf': 5} 最优分数: 0.9416666666666665\n"
     ]
    }
   ],
   "source": [
    "# 用GridSearchCV寻找最优参数（字典）\n",
    "param = {\n",
    "    'criterion': ['gini'],\n",
    "    'max_depth': [30, 50, 60, 100],\n",
    "    'min_samples_leaf': [2, 3, 5, 10],\n",
    "    'min_impurity_decrease': [0.1, 0.2, 0.5]\n",
    "}\n",
    "grid = GridSearchCV(DecisionTreeClassifier(), param_grid=param, cv=6)\n",
    "grid.fit(x_train, y_train)\n",
    "print('最优分类器:', grid.best_params_, '最优分数:', grid.best_score_)  # 得到最优的参数和分值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6daedbaa",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
